/*
 * Copyright 2017 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "modules/sksg/include/SkSGTransform.h"

#include "include/core/SkCanvas.h"
#include "modules/sksg/src/SkSGTransformPriv.h"

namespace sksg {
namespace {
template <typename T> SkMatrix AsSkMatrix(const T &);

template <> SkMatrix AsSkMatrix<SkMatrix>(const SkMatrix &m)
{
    return m;
}

template <> SkMatrix AsSkMatrix<SkM44>(const SkM44 &m)
{
    return m.asM33();
}

template <typename T> SkM44 AsSkM44(const T &);

template <> SkM44 AsSkM44<SkMatrix>(const SkMatrix &m)
{
    return SkM44(m);
}

template <> SkM44 AsSkM44<SkM44>(const SkM44 &m)
{
    return m;
}

template <typename T> class Concat final : public Transform {
public:
    template <typename = std::enable_if<std::is_same<T, SkMatrix>::value || std::is_same<T, SkM44>::value>>
    Concat(sk_sp<Transform> a, sk_sp<Transform> b) : fA(std::move(a)), fB(std::move(b))
    {
        SkASSERT(fA);
        SkASSERT(fB);

        this->observeInval(fA);
        this->observeInval(fB);
    }

    ~Concat() override
    {
        this->unobserveInval(fA);
        this->unobserveInval(fB);
    }

protected:
    SkRect onRevalidate(InvalidationController *ic, const SkMatrix &ctm) override
    {
        fA->revalidate(ic, ctm);
        fB->revalidate(ic, ctm);

        fComposed.setConcat(TransformPriv::As<T>(fA), TransformPriv::As<T>(fB));
        return SkRect::MakeEmpty();
    }

    bool is44() const override
    {
        return std::is_same<T, SkM44>::value;
    }

    SkMatrix asMatrix() const override
    {
        SkASSERT(!this->hasInval());
        return AsSkMatrix(fComposed);
    }

    SkM44 asM44() const override
    {
        SkASSERT(!this->hasInval());
        return AsSkM44(fComposed);
    }

private:
    const sk_sp<Transform> fA, fB;
    T fComposed;

    using INHERITED = Transform;
};

template <typename T> class Inverse final : public Transform {
public:
    template <typename = std::enable_if<std::is_same<T, SkMatrix>::value || std::is_same<T, SkM44>::value>>
    explicit Inverse(sk_sp<Transform> t) : fT(std::move(t))
    {
        SkASSERT(fT);

        this->observeInval(fT);
    }

    ~Inverse() override
    {
        this->unobserveInval(fT);
    }

protected:
    SkRect onRevalidate(InvalidationController *ic, const SkMatrix &ctm) override
    {
        fT->revalidate(ic, ctm);

        if (!TransformPriv::As<T>(fT).invert(&fInverted)) {
            fInverted.setIdentity();
        }

        return SkRect::MakeEmpty();
    }

    bool is44() const override
    {
        return std::is_same<T, SkM44>::value;
    }

    SkMatrix asMatrix() const override
    {
        SkASSERT(!this->hasInval());
        return AsSkMatrix(fInverted);
    }

    SkM44 asM44() const override
    {
        SkASSERT(!this->hasInval());
        return AsSkM44(fInverted);
    }

private:
    const sk_sp<Transform> fT;
    T fInverted;

    using INHERITED = Transform;
};
} // namespace

template <> SkMatrix Matrix<SkMatrix>::asMatrix() const
{
    return fMatrix;
}

template <> SkM44 Matrix<SkMatrix>::asM44() const
{
    return SkM44(fMatrix);
}

template <> SkMatrix Matrix<SkM44>::asMatrix() const
{
    return fMatrix.asM33();
}

template <> SkM44 Matrix<SkM44>::asM44() const
{
    return fMatrix;
}

// Transform nodes don't generate damage on their own, but via ancestor TransformEffects.
Transform::Transform() : INHERITED(kBubbleDamage_Trait) {}

sk_sp<Transform> Transform::MakeConcat(sk_sp<Transform> a, sk_sp<Transform> b)
{
    if (!a) {
        return b;
    }

    if (!b) {
        return a;
    }

    return TransformPriv::Is44(a) || TransformPriv::Is44(b) ?
        sk_sp<Transform>(new Concat<SkM44>(std::move(a), std::move(b))) :
        sk_sp<Transform>(new Concat<SkMatrix>(std::move(a), std::move(b)));
}

sk_sp<Transform> Transform::MakeInverse(sk_sp<Transform> t)
{
    if (!t) {
        return nullptr;
    }

    return TransformPriv::Is44(t) ? sk_sp<Transform>(new Inverse<SkM44>(std::move(t))) :
                                    sk_sp<Transform>(new Inverse<SkMatrix>(std::move(t)));
}

TransformEffect::TransformEffect(sk_sp<RenderNode> child, sk_sp<Transform> transform)
    : INHERITED(std::move(child)), fTransform(std::move(transform))
{
    this->observeInval(fTransform);
}

TransformEffect::~TransformEffect()
{
    this->unobserveInval(fTransform);
}

void TransformEffect::onRender(SkCanvas *canvas, const RenderContext *ctx) const
{
    SkAutoCanvasRestore acr(canvas, true);
    canvas->concat(TransformPriv::As<SkM44>(fTransform));

    this->INHERITED::onRender(canvas, ctx);
}

const RenderNode *TransformEffect::onNodeAt(const SkPoint &p) const
{
    const auto p4 = TransformPriv::As<SkM44>(fTransform).map(p.fX, p.fY, 0, 0);

    return this->INHERITED::onNodeAt({ p4.x, p4.y });
}

SkRect TransformEffect::onRevalidate(InvalidationController *ic, const SkMatrix &ctm)
{
    SkASSERT(this->hasInval());

    // We don't care about matrix reval results.
    fTransform->revalidate(ic, ctm);

    // TODO: need to update all the reval plumbing for m44.
    const auto m = TransformPriv::As<SkMatrix>(fTransform);
    auto bounds = this->INHERITED::onRevalidate(ic, SkMatrix::Concat(ctm, m));
    m.mapRect(&bounds);

    return bounds;
}
} // namespace sksg
